الأنماط السلوكية في بايثون: المراقب، الاستراتيجية، والأمر

تُعد أنماط التصميم السلوكية أدوات أساسية في ترسانة مطور البرامج. فهي تعالج مشاكل الاتصال والتفاعل الشائعة بين الكائنات، مما يؤدي إلى كود أكثر مرونة وقابلية للصيانة والتوسع. يتعمق هذا الدليل الشامل في ثلاثة أنماط سلوكية حاسمة في بايثون: المراقب (Observer)، والاستراتيجية (Strategy)، والأمر (Command). سنستكشف الغرض منها، وكيفية تنفيذها، وتطبيقاتها في العالم الحقيقي، مما يزودك بالمعرفة اللازمة للاستفادة من هذه الأنماط بفعالية في مشاريعك.

فهم الأنماط السلوكية

تركز الأنماط السلوكية على الاتصال والتفاعل بين الكائنات. فهي تحدد الخوارزميات وتعين المسؤوليات بين الكائنات، مما يضمن الاقتران المنخفض (loose coupling) والمرونة. باستخدام هذه الأنماط، يمكنك إنشاء أنظمة يسهل فهمها وتعديلها وتوسيعها.

تشمل الفوائد الرئيسية لاستخدام الأنماط السلوكية ما يلي:

• تحسين تنظيم الكود: من خلال تغليف سلوكيات محددة، تعزز هذه الأنماط الوحدوية والوضوح.
• مرونة معززة: تسمح لك بتغيير أو توسيع سلوك النظام دون تعديل مكوناته الأساسية.
• تقليل الاقتران: تعزز الأنماط السلوكية الاقتران المنخفض بين الكائنات، مما يسهل صيانة واختبار قاعدة الكود.
• زيادة قابلية إعادة الاستخدام: يمكن إعادة استخدام الأنماط نفسها، والكود الذي ينفذها، في أجزاء مختلفة من التطبيق أو حتى في مشاريع مختلفة.

نمط المراقب (Observer Pattern)

ما هو نمط المراقب؟

يحدد نمط المراقب تبعية "واحد إلى متعدد" بين الكائنات، بحيث عندما يغير كائن واحد (الموضوع - subject) حالته، يتم إعلام جميع توابعه (المراقبين - observers) وتحديثها تلقائيًا. هذا النمط مفيد بشكل خاص عندما تحتاج إلى الحفاظ على الاتساق عبر كائنات متعددة بناءً على حالة كائن واحد. يشار إليه أحيانًا أيضًا بنمط النشر والاشتراك (Publish-Subscribe).

فكر في الأمر مثل الاشتراك في مجلة. أنت (المراقب) تشترك لتلقي التحديثات (الإشعارات) كلما نشرت المجلة (الموضوع) عددًا جديدًا. لا تحتاج إلى التحقق باستمرار من وجود أعداد جديدة؛ يتم إعلامك تلقائيًا.

مكونات نمط المراقب

• الموضوع (Subject): الكائن الذي تكون حالته ذات أهمية. يحتفظ بقائمة من المراقبين ويوفر طرقًا لربط (اشتراك) وفصل (إلغاء اشتراك) المراقبين.
• المراقب (Observer): واجهة أو فئة مجردة تحدد طريقة التحديث (update)، التي يستدعيها الموضوع لإعلام المراقبين بتغيرات الحالة.
• الموضوع الملموس (ConcreteSubject): تنفيذ ملموس للموضوع، والذي يخزن الحالة ويخطر المراقبين عندما تتغير الحالة.
• المراقب الملموس (ConcreteObserver): تنفيذ ملموس للمراقب، والذي ينفذ طريقة التحديث للاستجابة لتغيرات الحالة في الموضوع.

التنفيذ في بايثون

فيما يلي مثال بلغة بايثون يوضح نمط المراقب:

class Subject:
    def __init__(self):
        self._observers = []
        self._state = None

    def attach(self, observer):
        self._observers.append(observer)

    def detach(self, observer):
        self._observers.remove(observer)

    def notify(self):
        for observer in self._observers:
            observer.update(self._state)

    @property
    def state(self):
        return self._state

    @state.setter
    def state(self, new_state):
        self._state = new_state
        self.notify()


class Observer:
    def update(self, state):
        raise NotImplementedError


class ConcreteObserverA(Observer):
    def update(self, state):
        print(f"ConcreteObserverA: State changed to {state}")


class ConcreteObserverB(Observer):
    def update(self, state):
        print(f"ConcreteObserverB: State changed to {state}")


# Example Usage
subject = Subject()

observer_a = ConcreteObserverA()
observer_b = ConcreteObserverB()

subject.attach(observer_a)
subject.attach(observer_b)

subject.state = "New State"
subject.detach(observer_a)
subject.state = "Another State"

في هذا المثال، يحتفظ `Subject` بقائمة من كائنات `Observer`. عندما تتغير `state` الخاصة بـ `Subject`، فإنه يستدعي طريقة `notify()`، التي تمر عبر قائمة المراقبين وتستدعي طريقة `update()` الخاصة بهم. ثم يتفاعل كل `ConcreteObserver` مع تغير الحالة وفقًا لذلك.

تطبيقات العالم الحقيقي

• معالجة الأحداث (Event Handling): في أطر عمل واجهات المستخدم الرسومية (GUI)، يُستخدم نمط المراقب على نطاق واسع لمعالجة الأحداث. عندما يتفاعل المستخدم مع عنصر واجهة المستخدم (مثل النقر على زر)، يقوم العنصر (الموضوع) بإعلام المستمعين المسجلين (المراقبين) بالحدث.
• بث البيانات: في التطبيقات المالية، تقوم مؤشرات الأسهم (المواضيع) ببث تحديثات الأسعار للعملاء المسجلين (المراقبين).
• تطبيقات جداول البيانات: عندما تتغير خلية في جدول بيانات، يتم إعادة حساب وتحديث الخلايا التابعة لها (المراقبين) تلقائيًا.
• إشعارات وسائل التواصل الاجتماعي: عندما ينشر شخص ما على منصة وسائط اجتماعية، يتم إعلام متابعيه (المراقبين).

مزايا نمط المراقب

• الاقتران المنخفض: لا يحتاج الموضوع والمراقبون إلى معرفة الفئات الملموسة لبعضهم البعض، مما يعزز الوحدوية وقابلية إعادة الاستخدام.
• قابلية التوسع: يمكن إضافة مراقبين جدد بسهولة دون تعديل الموضوع.
• المرونة: يمكن للموضوع إعلام المراقبين بمجموعة متنوعة من الطرق (مثل، بشكل متزامن أو غير متزامن).

عيوب نمط المراقب

• تحديثات غير متوقعة: يمكن إعلام المراقبين بتغييرات لا يهتمون بها، مما يؤدي إلى إهدار الموارد.
• سلاسل التحديث: يمكن أن تصبح التحديثات المتتالية معقدة وصعبة التصحيح.
• تسرب الذاكرة: إذا لم يتم فصل المراقبين بشكل صحيح، فقد لا يتمكن جامع القمامة من تحريرهم، مما يؤدي إلى تسرب الذاكرة.

نمط الاستراتيجية (Strategy Pattern)

ما هو نمط الاستراتيجية؟

يحدد نمط الاستراتيجية عائلة من الخوارزميات، ويغلف كل واحدة منها، ويجعلها قابلة للتبديل. يسمح نمط الاستراتيجية للخوارزمية بالتغير بشكل مستقل عن العملاء الذين يستخدمونها. هذا النمط مفيد عندما يكون لديك طرق متعددة لأداء مهمة ما، وتريد أن تكون قادرًا على التبديل بينها في وقت التشغيل دون تعديل كود العميل.

تخيل أنك تسافر من مدينة إلى أخرى. يمكنك اختيار استراتيجيات نقل مختلفة: الطائرة، القطار، أو السيارة. يسمح لك نمط الاستراتيجية باختيار أفضل استراتيجية نقل بناءً على عوامل مثل التكلفة والوقت والراحة، دون تغيير وجهتك.

مكونات نمط الاستراتيجية

• الاستراتيجية (Strategy): واجهة أو فئة مجردة تحدد الخوارزمية.
• الاستراتيجية الملموسة (ConcreteStrategy): تطبيقات ملموسة لواجهة الاستراتيجية، يمثل كل منها خوارزمية مختلفة.
• السياق (Context): فئة تحتفظ بمرجع إلى كائن استراتيجية وتفوض تنفيذ الخوارزمية إليه. لا يحتاج السياق إلى معرفة التنفيذ المحدد للاستراتيجية؛ فهو يتفاعل فقط مع واجهة الاستراتيجية.

التنفيذ في بايثون

فيما يلي مثال بلغة بايثون يوضح نمط الاستراتيجية:

class Strategy:
    def execute(self, data):
        raise NotImplementedError


class ConcreteStrategyA(Strategy):
    def execute(self, data):
        print("Executing Strategy A...")
        return sorted(data)


class ConcreteStrategyB(Strategy):
    def execute(self, data):
        print("Executing Strategy B...")
        return sorted(data, reverse=True)


class Context:
    def __init__(self, strategy):
        self._strategy = strategy

    def set_strategy(self, strategy):
        self._strategy = strategy

    def execute_strategy(self, data):
        return self._strategy.execute(data)


# Example Usage
data = [1, 5, 3, 2, 4]

strategy_a = ConcreteStrategyA()
context = Context(strategy_a)
result = context.execute_strategy(data)
print(f"Result with Strategy A: {result}")

strategy_b = ConcreteStrategyB()
context.set_strategy(strategy_b)
result = context.execute_strategy(data)
print(f"Result with Strategy B: {result}")

في هذا المثال، تحدد واجهة `Strategy` طريقة `execute()`. توفر `ConcreteStrategyA` و `ConcreteStrategyB` تطبيقات مختلفة لهذه الطريقة، حيث تقومان بفرز البيانات بترتيب تصاعدي وتنازلي على التوالي. تحتفظ فئة `Context` بمرجع إلى كائن `Strategy` وتفوض تنفيذ الخوارزمية إليه. يمكن للعميل التبديل بين الاستراتيجيات في وقت التشغيل عن طريق استدعاء طريقة `set_strategy()`.

تطبيقات العالم الحقيقي

• معالجة الدفع: تستخدم منصات التجارة الإلكترونية نمط الاستراتيجية لدعم طرق الدفع المختلفة (مثل بطاقة الائتمان، باي بال، التحويل البنكي). يتم تنفيذ كل طريقة دفع كاستراتيجية ملموسة.
• حساب تكلفة الشحن: يستخدم تجار التجزئة عبر الإنترنت نمط الاستراتيجية لحساب تكاليف الشحن بناءً على عوامل مثل الوزن والوجهة وطريقة الشحن.
• ضغط الصور: تستخدم برامج تحرير الصور نمط الاستراتيجية لدعم خوارزميات ضغط الصور المختلفة (مثل JPEG، PNG، GIF).
• التحقق من صحة البيانات: يمكن لنماذج إدخال البيانات استخدام استراتيجيات تحقق مختلفة بناءً على نوع البيانات التي يتم إدخالها (مثل عنوان البريد الإلكتروني، رقم الهاتف، التاريخ).
• خوارزميات التوجيه: تستخدم أنظمة الملاحة GPS خوارزميات توجيه مختلفة (مثل أقصر مسافة، أسرع وقت، أقل ازدحامًا) بناءً على تفضيلات المستخدم.

مزايا نمط الاستراتيجية

• المرونة: يمكنك بسهولة إضافة استراتيجيات جديدة دون تعديل السياق.
• قابلية إعادة الاستخدام: يمكن إعادة استخدام الاستراتيجيات في سياقات مختلفة.
• التغليف: يتم تغليف كل استراتيجية في فئتها الخاصة، مما يعزز الوحدوية والوضوح.
• مبدأ الفتح/الإغلاق: يمكنك توسيع النظام بإضافة استراتيجيات جديدة دون تعديل الكود الحالي.

عيوب نمط الاستراتيجية

• زيادة التعقيد: يمكن أن يزداد عدد الفئات، مما يجعل النظام أكثر تعقيدًا.
• وعي العميل: يحتاج العميل إلى أن يكون على دراية بالاستراتيجيات المختلفة المتاحة واختيار الاستراتيجية المناسبة.

نمط الأمر (Command Pattern)

ما هو نمط الأمر؟

يقوم نمط الأمر بتغليف طلب ككائن، مما يتيح لك تحديد معلمات العملاء بطلبات مختلفة، ووضع الطلبات في قائمة انتظار أو تسجيلها، ودعم العمليات القابلة للتراجع. يفصل هذا النمط الكائن الذي يستدعي العملية عن الكائن الذي يعرف كيفية تنفيذها.

فكر في مطعم. أنت (العميل) تقدم طلبًا (أمرًا) إلى النادل (المستدعي - invoker). لا يقوم النادل بإعداد الطعام بنفسه؛ بل يمرر الطلب إلى الطاهي (المستقبل - receiver)، الذي ينفذ الإجراء فعليًا. يسمح لك نمط الأمر بفصل عملية الطلب عن عملية الطهي.

مكونات نمط الأمر

• الأمر (Command): واجهة أو فئة مجردة تعلن عن طريقة لتنفيذ طلب.
• الأمر الملموس (ConcreteCommand): تطبيقات ملموسة لواجهة الأمر، والتي تربط كائن مستقبل (receiver) بإجراء معين.
• المستقبل (Receiver): الكائن الذي يقوم بالعمل الفعلي.
• المستدعي (Invoker): الكائن الذي يطلب من الأمر تنفيذ الطلب. يحتفظ بكائن أمر ويستدعي طريقته التنفيذية لبدء العملية.
• العميل (Client): ينشئ كائنات الأمر الملموسة (ConcreteCommand) ويحدد مستقبلها (receiver).

التنفيذ في بايثون

فيما يلي مثال بلغة بايثون يوضح نمط الأمر:

class Command:
    def execute(self):
        raise NotImplementedError


class ConcreteCommand(Command):
    def __init__(self, receiver, action):
        self._receiver = receiver
        self._action = action

    def execute(self):
        self._receiver.action(self._action)


class Receiver:
    def action(self, action):
        print(f"Receiver: Performing action '{action}'")


class Invoker:
    def __init__(self):
        self._commands = []

    def add_command(self, command):
        self._commands.append(command)

    def execute_commands(self):
        for command in self._commands:
            command.execute()


# Example Usage
receiver = Receiver()

command1 = ConcreteCommand(receiver, "Operation 1")
command2 = ConcreteCommand(receiver, "Operation 2")

invoker = Invoker()
invoker.add_command(command1)
invoker.add_command(command2)

invoker.execute_commands()

في هذا المثال، تحدد واجهة `Command` طريقة `execute()`. يربط `ConcreteCommand` كائن `Receiver` بإجراء محدد. تحتفظ فئة `Invoker` بقائمة من كائنات `Command` وتنفذها بالتسلسل. يقوم العميل بإنشاء كائنات `ConcreteCommand` وإضافتها إلى `Invoker`.

تطبيقات العالم الحقيقي

• أشرطة الأدوات والقوائم في واجهة المستخدم الرسومية: يمكن تمثيل كل زر أو عنصر قائمة كأمر. عندما ينقر المستخدم على زر، يتم تنفيذ الأمر المقابل.
• معالجة المعاملات: في أنظمة قواعد البيانات، يمكن تمثيل كل معاملة كأمر. هذا يسمح بوظائف التراجع/الإعادة وتسجيل المعاملات.
• تسجيل الماكرو: تستخدم ميزات تسجيل الماكرو في تطبيقات البرامج نمط الأمر لالتقاط إجراءات المستخدم وإعادة تشغيلها.
• قوائم انتظار المهام (Job Queues): الأنظمة التي تعالج المهام بشكل غير متزامن غالبًا ما تستخدم قوائم انتظار المهام، حيث يتم تمثيل كل مهمة كأمر.
• استدعاء الإجراءات عن بعد (RPC): تستخدم آليات RPC نمط الأمر لتغليف استدعاءات الطرق عن بعد.

مزايا نمط الأمر

• الفصل (Decoupling): يتم فصل المستدعي والمستقبل، مما يتيح مرونة وقابلية إعادة استخدام أكبر.
• الجدولة والتسجيل: يمكن وضع الأوامر في قائمة انتظار وتسجيلها، مما يتيح ميزات مثل التراجع/الإعادة ومسارات التدقيق.
• المعلمات (Parameterization): يمكن تخصيص الأوامر بمعلمات مع طلبات مختلفة، مما يجعلها أكثر تنوعًا.
• دعم التراجع/الإعادة: يسهل نمط الأمر تنفيذ وظيفة التراجع/الإعادة.

عيوب نمط الأمر

• زيادة التعقيد: يمكن أن يزداد عدد الفئات، مما يجعل النظام أكثر تعقيدًا.
• عبء إضافي (Overhead): يمكن أن يؤدي إنشاء كائنات الأوامر وتنفيذها إلى بعض العبء الإضافي.

الخاتمة

تُعد أنماط المراقب، والاستراتيجية، والأمر أدوات قوية لبناء أنظمة برمجية مرنة وقابلة للصيانة والتوسع في بايثون. من خلال فهم الغرض منها، وتنفيذها، وتطبيقاتها في العالم الحقيقي، يمكنك الاستفادة من هذه الأنماط لحل مشاكل التصميم الشائعة وإنشاء تطبيقات أكثر قوة وقابلية للتكيف. تذكر أن تضع في اعتبارك المقايضات المرتبطة بكل نمط واختيار النمط الذي يناسب احتياجاتك الخاصة على أفضل وجه. إن إتقان هذه الأنماط السلوكية سيعزز بشكل كبير قدراتك كمهندس برمجيات.